home *** CD-ROM | disk | FTP | other *** search
/ QRZ! Ham Radio 4 / QRZ Ham Radio Callsign Database - Volume 4.iso / files / amiga / 7pl204am.lzh / 7PLUS204 / SOURCE / UTILS.C < prev   
Encoding:
C/C++ Source or Header  |  1992-11-22  |  30.3 KB  |  1,515 lines
  1. #include "7plus.h"
  2. #include "globals.h"
  3.  
  4. #ifdef __unix__
  5.  #ifdef __M_XENIX__
  6.   struct utimbuf {
  7.    time_t actime;
  8.    time_t modtime;
  9.   };
  10.   extern time_t mktime (struct tm *utm);
  11.  #else
  12.   #include <utime.h>
  13.  #endif
  14. #endif
  15.  
  16. #ifdef _AMIGA_
  17.  struct utimbuf {
  18.    time_t actime;
  19.    time_t modtime;
  20.  };
  21.  extern time_t mktime (struct tm *utm);
  22. #endif
  23.  
  24. static char no[] = NO, yes[] = YES, always[] = ALWAYS;
  25.  
  26. /*
  27. *** get a line from file. don't care about type of line separator.
  28. ***
  29. ***
  30.  */
  31.  
  32. char *my_fgets (char *string, register n, FILE *rein)
  33. {
  34.   register in, i;
  35.  
  36.   if (feof (rein))
  37.     return (NULL);
  38.  
  39.   i = 0;
  40.   while ((in = fgetc (rein)) != EOF)
  41.   {
  42.     if (in == 0x0d)
  43.     {
  44.       if ((in = fgetc (rein)) != 0x0a)
  45.         if (in != EOF)
  46.           ungetc (in, rein);
  47.       in = 0x0a;
  48.     }
  49.     string[i++] = (char) in;
  50.     if (i == n || in == 0x0a)
  51.       break;
  52.   }
  53.   string[i] = EOS;
  54.   return (string);
  55. } 
  56.  
  57. /*
  58. ***
  59. *** Write a byte to file.
  60. ***
  61.  */
  62.  
  63. int my_putc (int outchar, FILE *out)
  64. {
  65.   register x;
  66.  
  67.   if ((x = putc ((char) outchar, out)) == EOF)
  68.   {
  69.     printf ("\007\nWrite error! Can't continue.\n");
  70.     exit (1);
  71.   }
  72.   return (x);
  73. }
  74.  
  75. /*
  76. *** Get crc and line number from code line.
  77. ***
  78. ***
  79.  */
  80.  
  81. void crc_n_lnum (uint *crc, int *linenumber, char *line)
  82. {
  83.   register ulong cs;
  84.  
  85.   cs = 0xb640L * decode[(byte)line[66]] +
  86.        0xd8L   * decode[(byte)line[65]] +
  87.                  decode[(byte)line[64]];
  88.  
  89.   *linenumber = (int) (cs >> 14);   /* upper 9 bits are the line number */
  90.   *crc = (uint) (cs & 0x3fffL);     /* lower 14 bits are the CRC */
  91. }
  92.  
  93. /*
  94. *** Get crc2 from code line.
  95. ***
  96. ***
  97.  */
  98.  
  99. void crc2 (uint *crc, char *line)
  100. {
  101.  
  102.   *crc = 0xd8 * decode[(byte)line[68]] +
  103.                 decode[(byte)line[67]];
  104. }
  105.  
  106. /*
  107. *** Whip up 2nd CRC
  108. ***
  109. ***
  110.  */
  111.  
  112. void add_crc2 (char *line)
  113. {
  114.   register uint crc;
  115.   register int i;
  116.  
  117.   /* Whip up 2nd CRC */
  118.   crc = 0;
  119.   for (i=66;i>-1;i--)
  120.     crc = crctab[crc>>8] ^ (((crc&255)<<8) | (byte) line[i]);
  121.   crc &= 0x7fff;
  122.  
  123.   i = 67;
  124.   line[i++] = code[crc % 0xd8];
  125.   line[i++] = code[crc / 0xd8];
  126.   line[i] = EOS;
  127. }
  128.  
  129. /*
  130. *** mini-crc for header. safe enough...
  131. ***
  132. ***
  133.  */
  134.  
  135. int mcrc (char *line, int flag)
  136. {
  137.   register int i, j;
  138.   register uint crc;
  139.   char test[3], *p;
  140.  
  141.   sprintf (test, "\xb0\xb1");
  142.  
  143.   if ((p = strstr (line, test)) == NULL)
  144.     return (0);
  145.  
  146.   j = (int) (p - line) + 4;
  147.  
  148.   for (i=crc=0; i<j; i++)
  149.     crc = crctab[crc>>8] ^ (((crc&255)<<8) | (byte)line[i]);
  150.   crc %= 216;
  151.   if (!flag)
  152.   {
  153.     if (crc == (uint) decode[(byte)line[j]])
  154.       return (1);
  155.     else
  156.       return (0);
  157.   }
  158.   else
  159.     line[j] = code[(byte)crc];
  160.  
  161.   return (crc);
  162. }
  163.  
  164. /*
  165. *** read info from indexfile
  166. ***
  167. ***
  168.  */
  169.  
  170. int read_index (FILE *ifile, struct m_index *index)
  171. {
  172.   int j;
  173.   ulong i, begin, end;
  174.  
  175.   #ifdef _CHSIZE_OK
  176.    fseek (ifile, -4L, SEEK_END);
  177.    fseek (ifile, read_ulong (ifile), SEEK_SET);
  178.   #endif
  179.  
  180.   /* clear index */
  181.   for (j = 0;j < 4080; j++)
  182.     index->lines_ok[j] = 0UL;
  183.  
  184.   my_fgets (index->full_name, 12, ifile);
  185.   if (strcmp(index->full_name, "7PLUS-index\x0a"))
  186.   {
  187.     printf ("\007No index info found.\n");
  188.     return (1);
  189.   }
  190.   my_fgets (index->filename, 13, ifile);
  191.   index->filename[(int)strlen(index->filename)-1] = EOS;
  192.   my_fgets (index->full_name, 257, ifile);
  193.   index->full_name[(int)strlen(index->full_name)-1] = EOS;
  194.   index->timestamp = read_ulong (ifile);
  195.   index->splitsize = read_uint  (ifile);
  196.   index->lines_left= (long) read_ulong (ifile);
  197.  
  198.   /* convert defect list into bitvektor */
  199.   while (1==1)
  200.   {
  201.     if ((begin = read_ulong (ifile)) == 0xffffffffUL)
  202.       break;
  203.     end = read_ulong (ifile);
  204.  
  205.     if ((end>>5) > (begin>>5))
  206.       for (i = begin;i < ((begin |31UL) + 1UL); i++)
  207.         index->lines_ok[(int)i>>5] |= (1UL <<(i&31UL));
  208.     else
  209.     {
  210.       for (i = begin;i < end; i++)
  211.         index->lines_ok[(int)i>>5] |= (1UL <<(i&31UL));
  212.       continue;
  213.     }
  214.  
  215.     for (i = (begin>>5) +1; i < (end>>5); i++)
  216.       index->lines_ok[(int)i] = 0xffffffffUL;
  217.  
  218.     if (end&31)
  219.       for (i = end &0xffffffe0UL; i < end; i++)
  220.         index->lines_ok[(int)i>>5] |= (1UL <<(i&31UL));
  221.   }
  222.   index->length = read_ulong (ifile);
  223.  
  224.   #ifdef _CHSIZE_OK
  225.    fseek (ifile, 0UL, SEEK_SET);
  226.   #endif
  227.  
  228.   return (0);
  229. }
  230.  
  231. /*
  232. *** write info to indexfile
  233. ***
  234. ***
  235.  */
  236.  
  237. int write_index (FILE *ifile, struct m_index *index, int flag)
  238. {
  239.   int j, part, prevpart, lines;
  240.   ulong i, begin, end;
  241.  
  242.   part = prevpart = lines = 0;
  243.   begin = end = 0UL;
  244.  
  245.   if (!flag)
  246.   {
  247.     #ifdef _CHSIZE_OK
  248.      fseek (ifile, index->length, SEEK_SET);
  249.     #endif
  250.  
  251.     fprintf (ifile, "7PLUS-index\n");
  252.     fprintf (ifile, "%s\n", index->filename);
  253.     fprintf (ifile, "%s\n", index->full_name);
  254.     write_ulong (ifile, index->timestamp);
  255.     write_uint  (ifile, index->splitsize);
  256.     write_ulong (ifile, (ulong) index->lines_left);
  257.   }
  258.   /* convert bitvektor into defect list */
  259.   i = 0UL;
  260.   j = 0;
  261.   while (1==1)
  262.   {
  263.     while (j < 4080 && !(index->lines_ok[j] &(1UL <<(i & 31UL))))
  264.     {
  265.       if (!(i&31UL) && index->lines_ok[j] == 0UL)
  266.       {
  267.         j++;
  268.         i = (ulong) j<<5;
  269.       }
  270.       else
  271.       {
  272.         i++;
  273.         j = (int) i>>5;
  274.       }
  275.     }
  276.  
  277.     if (j == 4080)
  278.       break;
  279.  
  280.     begin = i;
  281.  
  282.     do
  283.     {
  284.       if (!(i&31UL) && index->lines_ok[j] == 0xffffffffUL)
  285.       {
  286.         j++;
  287.         i = (ulong) j<<5;
  288.       }
  289.       else
  290.       {
  291.         i++;
  292.         j = (int) i>>5;
  293.       }
  294.     }
  295.     while (j < 4080 && (index->lines_ok[j] &(1UL <<(i & 31UL))));
  296.  
  297.     end = i;
  298.  
  299.     if (!flag)
  300.     {
  301.       write_ulong (ifile, begin);
  302.       write_ulong (ifile, end);
  303.     }
  304.     else
  305.     {
  306.       for (i = begin; i < end; i++)
  307.       {
  308.         part = (int) i / index->splitsize +1;
  309.         if (part != prevpart)
  310.         {
  311.           if (prevpart)
  312.           {
  313.             if (!(lines % 18) && lines)
  314.               fprintf (ifile, delimit);
  315.             lines = 0;
  316.             fprintf (ifile, "FFF%s", delimit);
  317.           }
  318.           prevpart = part;
  319.           fprintf (ifile, "%02X%s", part, delimit);
  320.         }
  321.  
  322.         lines++; /* Number of missing or corrupted lines in this part. */
  323.         fprintf (ifile, "%03X", (uint)(i % index->splitsize));
  324.         if (!(lines % 18) && lines)
  325.         {
  326.           fprintf (ifile, delimit);
  327.           lines = 0;
  328.         }
  329.         else
  330.           fprintf (ifile, " ");
  331.       }
  332.     }
  333.   }
  334.  
  335.   if (!flag)
  336.   {
  337.     write_ulong (ifile, 0xffffffffUL);
  338.     write_ulong (ifile, index->length);
  339.     #ifdef _CHSIZE_OK
  340.      chsize (fileno (ifile), ftell (ifile));
  341.     #endif
  342.   }
  343.   else
  344.   {
  345.     if (!(lines % 18) && lines)
  346.       fprintf (ifile, delimit);
  347.     fprintf (ifile, "FFF%s", delimit);
  348.   }
  349.   return (0);
  350. }
  351.  
  352. /*
  353. *** Reading/writing unsigned long(32bit)/int(16)
  354. ***
  355. ***
  356.  */
  357.  
  358. ulong read_ulong (FILE *in)
  359. {
  360.   return ((ulong)fgetc (in)       +
  361.          ((ulong)fgetc (in) <<8 ) +
  362.          ((ulong)fgetc (in) <<16) +
  363.          ((ulong)fgetc (in) <<24));
  364. }
  365.  
  366. uint read_uint (FILE *in)
  367. {
  368.   return ((uint)fgetc (in)       +
  369.          ((uint)fgetc (in) <<8 ));
  370. }
  371.  
  372. void write_ulong (FILE *out, ulong val)
  373. {
  374.   my_putc ((int) (val     &0xffUL), out);
  375.   my_putc ((int)((val>>8 )&0xffUL), out);
  376.   my_putc ((int)((val>>16)&0xffUL), out);
  377.   my_putc ((int)((val>>24)&0xffUL), out);
  378. }
  379.  
  380. void write_uint (FILE *out, uint val)
  381. {
  382.   my_putc ((int) (val    &0xffU), out);
  383.   my_putc ((int)((val>>8)&0xffU), out);
  384. }
  385.  
  386. /*
  387. *** read a file, search for s1, calculate CRC until s2 is found.
  388. *** flag == 1: compare calculated an read CRC.
  389. *** flag == 0: insert CRC into file.
  390.  */
  391.  
  392. int crc_file (char *file, char *s1, char *s2, int flag)
  393. {
  394.   char line[81], *p;
  395.   uint crc, cs;
  396.   int i, j, k;
  397.   FILE *in;
  398.  
  399.   crc = cs = 0;
  400.   p = NULLCP;
  401.  
  402.   if (!(in = fopen (file, OPEN_RANDOM_BINARY)))
  403.   {
  404.     printf (cant, file);
  405.     return (2);
  406.   }
  407.  
  408.   i = (int) strlen (s1);
  409.   k = (int) strlen (s2);
  410.  
  411.   j = 1;
  412.  
  413.   do
  414.   {
  415.     if (my_fgets (line, 80, in) == NULL)
  416.       break;
  417.  
  418.     j = strncmp (line, s1, i);
  419.   }
  420.   while (j);
  421.  
  422.   if (j)
  423.     p = s1;
  424.   else
  425.   {
  426.     p = s2;
  427.     do
  428.     {
  429.       for (i=0;i!=(int)strlen(line);i++)
  430.         crc = crctab[crc>>8] ^ (((crc&255)<<8) | (byte)line[i]);
  431.  
  432.       j = strncmp (line, s2, k);
  433.  
  434.       if (!j)
  435.         continue;
  436.  
  437.       if (my_fgets (line, 80, in) == NULL)
  438.         break;
  439.     }
  440.     while (j);
  441.   }
  442.  
  443.   if (j)
  444.   {
  445.     printf ("\n\007Can't calculate CRC\n");
  446.     printf ("String '%s' not found in '%s'.\nBreak.\n", p, file);
  447.     return (7);
  448.   }
  449.  
  450.   /* evaluate CRC */
  451.   if (flag)
  452.   {
  453.     my_fgets (line, 80, in);
  454.     fclose (in);
  455.     if (!line || strncmp ("CRC ", line, 4))
  456.     {
  457.       printf ("\n'%s': no CRC found.\n(File may be corrupted or from version \
  458. earlier than 7PLUS v1.5)\n", file);
  459.       return (17);
  460.     }
  461.     cs = get_hex (line+4);
  462.     if (cs == crc)
  463.       return (0);
  464.  
  465.     printf ("\007\n'%s' is corrupted. Break.\n", file);
  466.     return (7);
  467.   }
  468.  
  469.   /* insert CRC into file */
  470.   fseek (in, 0UL, SEEK_CUR);
  471.   fprintf (in, "CRC %04X", crc);
  472.   fclose (in);
  473.  
  474.   return (0);
  475. }
  476.  
  477. /*
  478. *** Copy a file.
  479. ***
  480. ***
  481.  */
  482.  
  483. int copy_file (char *to, char *from, ulong timestamp)
  484. {
  485.   FILE *_from, *_to;
  486.   int _char, stat;
  487.  
  488.   stat = 0;
  489.  
  490.   _from = fopen (from, OPEN_READ_BINARY);
  491.   _to   = fopen (to,   OPEN_WRITE_BINARY);
  492.  
  493.   while ((_char = getc (_from)) != EOF)
  494.     if ((stat = putc (_char, _to)) == EOF)
  495.       break;
  496.  
  497.   fclose (_from);
  498.  
  499.  #if defined (__MSDOS__) || (__TOS__)
  500.   if (timestamp)
  501.     set_filetime (_to, timestamp);
  502.  
  503.   fclose (_to);
  504.  #else
  505.   fclose (_to);
  506.  
  507.   if (timestamp)
  508.     set_filetime (to, timestamp);
  509.  #endif
  510.  
  511.   if (stat == EOF)
  512.   {
  513.     printf ("\007\nFatal error. Can't write '%s'! Break.\n", to);
  514.     exit (1);
  515.   }
  516.   return (0);
  517. }
  518.  
  519. /*
  520. *** Replace one file with another
  521. ***
  522. ***
  523.  */
  524.  
  525. void replace (char *old, char *new, ulong timestamp)
  526. {
  527.   unlink (old);
  528.  
  529.   if (rename (new, old))
  530.   {
  531.     copy_file (old, new, timestamp);
  532.     unlink (new);
  533.   }
  534.   else
  535.   {
  536.     if (timestamp)
  537.     {
  538.      #if defined (__MSDOS__) || (__TOS__)
  539.       FILE *_file;
  540.  
  541.       _file = fopen (old, OPEN_APPEND_BINARY);
  542.       set_filetime (_file, timestamp);
  543.       fclose (_file);
  544.      #else
  545.       set_filetime (old, timestamp);
  546.      #endif
  547.     }
  548.   }
  549. }
  550.  
  551. /*
  552. *** Kill all files that aren't needed any more
  553. ***
  554. ***
  555.  */
  556.  
  557. void kill_em (char *name, char *inpath, char *one, char *two,
  558.               char *three, char *four, char *five)
  559. {
  560.   char *p, newname[MAXPATH];
  561.   int i, j, k, len;
  562.  
  563.   k = 0;
  564.  
  565.   for (i = 0; i < 5; i++)
  566.   {
  567.     if (!i)
  568.       printf ("\n");
  569.  
  570.     switch (i)
  571.     {
  572.       case 0:  p = one;
  573.                break;
  574.       case 1:  p = two;
  575.                break;
  576.       case 2:  p = three;
  577.                break;
  578.       case 3:  p = four;
  579.                break;
  580.       case 4:  p = five;
  581.  
  582.       default: p = NULLCP;
  583.     }
  584.     if (!p)
  585.      break;
  586.  
  587.     len = strlen(p);
  588.  
  589.     for (j = 1; j <256; j++)
  590.     {
  591.       if (len == 3)
  592.         sprintf (newname, "%s%s.%s", inpath, name, p);
  593.       else
  594.         sprintf (newname, "%s%s.%s%02x", inpath, name, p, j);
  595.  
  596.       if (unlink (newname))
  597.         break;
  598.  
  599.       k++;
  600.  
  601.       printf ("Deleting: %s\r", newname);
  602.       fflush (stdout);
  603.  
  604.       if (len == 3)
  605.         break;
  606.     }
  607.   }
  608.   if (k)
  609.     printf ("\n");
  610. }
  611.  
  612. /*
  613. ***
  614. ***
  615. ***
  616.  */
  617.  
  618. void kill_dest (FILE *in, FILE *out, char *name)
  619. {
  620.     if (out)
  621.       fclose (out);
  622.     if (in)
  623.       fclose (in);
  624.     if (*name)
  625.       unlink (name);
  626. }
  627.  
  628. /*
  629. ***
  630. ***  test if a file exists at all
  631. ***
  632.  */
  633.  
  634. int test_exist (char *filename)
  635. {
  636.   FILE *in = NULLFP;
  637.  
  638.   if ((in = fopen (filename, OPEN_READ_TEXT)) != NULLFP)
  639.   {
  640.     fclose (in);
  641.     return (0);
  642.   }
  643.   return (1);
  644. }
  645.  
  646.  
  647. /*
  648. ***  test if outputfile already exists. prompt for overwrite or
  649. ***  new name.
  650. ***
  651.  */
  652.  
  653. int test_file (FILE *in, char *destnam, int flag, int namsize)
  654. {
  655.    FILE *out;
  656.    int  i, ret;
  657.  
  658.    ret = 0;
  659.  
  660.    if (noquery)
  661.      return (ret);
  662.  
  663.    /* Loop as long as file can be opened. */
  664.    while ((out = fopen (destnam, OPEN_READ_BINARY)) != NULLFP)
  665.    {
  666.      ret = 1;
  667.      printf ("\007\nOutputfile '%s' already exists, overwrite? [y/n/a] ", destnam);
  668.      do
  669.      {
  670.        i = getch();
  671.        i = toupper(i);
  672.  
  673.        if (i == 'N')
  674.        {
  675.          if (flag)
  676.          {
  677.            #ifdef _AMIGA_
  678.             printf ("Enter new name (max %d chars)\n", namsize);
  679.             printf ("or press <CNTL>+C <RETURN> to break : ");
  680.  
  681.             if (namsize == 12)
  682.               strlwr (destnam);
  683.  
  684.             scanf("%s",destnam);
  685.             destnam[namsize] = EOS;
  686.            #else
  687.             printf ("%s\nEnter new name (max %d chars)\n", no, namsize);
  688.             printf ("or simply press ENTER to break : ");
  689.  
  690.             if (namsize == 12)
  691.               strlwr (destnam);
  692.  
  693.             i = getc(stdin);
  694.             if(i != '\n')
  695.             {
  696.               ungetc(i, stdin);
  697.               scanf ("%s", destnam);
  698.               fflush (stdin);
  699.             }
  700.             else
  701.               destnam[0] = EOS;
  702.             destnam[namsize] = EOS;
  703.            #endif
  704.          }
  705.          else
  706.            *destnam = EOS;
  707.          if (!strlen (destnam))
  708.          {
  709.            if (!flag)
  710.              printf ("%s\n", no);
  711.            printf ("Break.\n");
  712.            if (in)
  713.              fclose (in);
  714.            exit (10);
  715.          }
  716.          i = 0xff; /* indicate, that new name has been specified */
  717.        }
  718.      }
  719.      while (i != 'Y' && i != 'A' && i != 0xff);
  720.  
  721.      if (i != 0xff)
  722.      {
  723.        if (i == 'A')
  724.        {
  725.          printf ("%s\n", always);
  726.          noquery = 1;
  727.        }
  728.        else
  729.          printf ("%s\n", yes);
  730.      }
  731.      printf ("\n");
  732.  
  733.      fclose (out);
  734.  
  735.      if (i != 0xff)
  736.        break;
  737.    }
  738.  
  739.    return (ret);
  740. }
  741.  
  742.  
  743. /*
  744. *** initialize decoding table
  745. ***
  746. ***
  747.  */
  748.  
  749. void init_decodetab (void)
  750. {
  751.   register i;
  752.   register byte j;
  753.  
  754.   for (i = 0; i < 256; i++)
  755.     decode[i] = 255;
  756.  
  757.   j = 0;
  758.   for (i = 0x21; i < 0x2a; i++)
  759.     decode[i] = j++;
  760.  
  761.   for (i = 0x2b; i < 0x7f; i++)
  762.     decode[i] = j++;
  763.  
  764.   for (i = 0x80; i < 0x91; i++)
  765.     decode[i] = j++;
  766.  
  767.   decode[0x92] = j++;
  768.  
  769.   for (i = 0x94; i < 0xfd; i++)
  770.     decode[i] = j++;
  771. }
  772.  
  773. /*
  774. *** initialize encoding table
  775. ***
  776. ***
  777.  */
  778.  
  779. void init_codetab (void)
  780. {
  781.   register byte i, j;
  782.  
  783.   j = 0;
  784.  
  785.   for (i = 0x21; i < 0x2a; i++, j++)
  786.     code[j] = i;
  787.  
  788.   for (i = 0x2b; i < 0x7f; i++, j++)
  789.     code[j] = i;
  790.  
  791.   for (i = 0x80; i < 0x91; i++, j++)
  792.     code[j] = i;
  793.  
  794.   code[j++] = 146;
  795.  
  796.   for (i = 0x94; i < 0xfd; i++, j++)
  797.     code[j] = i;
  798. }
  799.  
  800. /*
  801. *** Tnx to DC4OX.
  802. ***
  803. *** calculate CRC-table
  804. ***
  805.  */
  806.  
  807. void init_crctab (void)
  808. {
  809.   uint m, n, r, mask;
  810.  
  811.   static uint bitrmdrs[] = { 0x9188,0x48C4,0x2462,0x1231,
  812.                              0x8108,0x4084,0x2042,0x1021 };
  813.  
  814.   for (n = 0; n < 256; ++n)
  815.   {
  816.     for (mask = 0x0080, r = 0, m = 0; m < 8; ++m, mask >>= 1)
  817.       if (n & mask)
  818.         r = bitrmdrs[m] ^ r;
  819.     crctab[n] = r;
  820.   }
  821. }
  822.  
  823. /*
  824. *** Create a MSDOS/ATARI compatible filename.
  825. ***
  826. ***
  827.  */
  828.  
  829. void build_DOS_name (char *name)
  830. {
  831.   char tmp[MAXFNAME];
  832.   register i, j;
  833.  
  834.   i = j = 0;
  835.  
  836.   strcpy (tmp, name);
  837.   strlwr (tmp);
  838.  
  839.   if (*tmp)
  840.   {
  841.     do
  842.     {
  843.       tmp[i] &= 127;
  844.       if (strchr (" <>=,;:*?&[]()/.\\\"~+@", tmp[i]) == NULL)
  845.         name[j++] = tmp[i];
  846.     }
  847.     while (tmp[++i]);
  848.  
  849.     name[j] = EOS;
  850.   }
  851. }
  852.  
  853. #if defined (__MSDOS__) || (__TOS__)
  854.  /*
  855.  *** Get file's timestamp and package it into a 32-bit word (MS_DOS-format)
  856.  ***
  857.  ***
  858.   */
  859.  ulong get_filetime (FILE *_file)
  860.  {
  861.   ulong    ftimestamp;
  862.  
  863.   if (getftime (fileno(_file), (struct ftime *)&ftimestamp) == EOF)
  864.     printf ("\007\nCan't get file's timestamp!\n");
  865.  
  866.  #ifdef __TOS__
  867.   ftimestamp = swapl(ftimestamp);
  868.  #endif
  869.  
  870.   return (ftimestamp);
  871.  }
  872.  
  873.  #define _SETFTIME_OK
  874.  /*
  875.  *** Set file's timestamp
  876.  ***
  877.  ***
  878.   */
  879.  void set_filetime (FILE *_file, ulong ftimestamp)
  880.  {
  881.  #ifdef __TOS__
  882.   ftimestamp = swapl(ftimestamp);
  883.  #endif
  884.  
  885.   if (setftime (fileno(_file), (struct ftime *)&ftimestamp) == EOF)
  886.     printf ("\007\nCan't set file's timestamp!");
  887.  }
  888.  
  889. #else /* it's not an MSDOS or Atari system */
  890.  #ifndef _HAVE_GMTIME
  891.   /*
  892.   * mktime function from GNU C library V1.03; modified:
  893.   * - expanded DEFUN and CONST macros from ansidecl.h
  894.   * - inserted __isleap macro from time.h
  895.   * - inserted __mon_lengths array and __offtime function from offtime.c
  896.   * - inserted gmtime function from gmtime.c
  897.   * - commented out call of localtime function
  898.   * Be aware of the following copyright message for mktime !!!
  899.   */
  900.  
  901.   /* Copyright (C) 1991 Free Software Foundation, Inc.
  902.   This file is part of the GNU C Library.
  903.  
  904.   The GNU C Library is free software; you can redistribute it and/or
  905.   modify it under the terms of the GNU Library General Public License as
  906.   published by the Free Software Foundation; either version 2 of the
  907.   License, or (at your option) any later version.
  908.  
  909.   The GNU C Library is distributed in the hope that it will be useful,
  910.   but WITHOUT ANY WARRANTY; without even the implied warranty of
  911.   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  912.   Library General Public License for more details.
  913.  
  914.   You should have received a copy of the GNU Library General Public
  915.   License along with the GNU C Library; see the file COPYING.LIB.  If
  916.   not, write to the Free Software Foundation, Inc., 675 Mass Ave,
  917.   Cambridge, MA 02139, USA.  */
  918.  
  919.  
  920.   /* How many days are in each month.  */
  921.   const unsigned short int __mon_lengths[2][12] =
  922.     {
  923.       /* Normal years.  */
  924.       { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
  925.       /* Leap years.  */
  926.       { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
  927.     };
  928.  
  929.   #define  __isleap(year)  \
  930.     ((year) % 4 == 0 && ((year) % 100 != 0 || (year) % 400 == 0))
  931.  
  932.   #define  invalid()  return (time_t) -1
  933.  
  934.  
  935.   #define  SECS_PER_HOUR  (60 * 60)
  936.   #define  SECS_PER_DAY  (SECS_PER_HOUR * 24)
  937.  
  938.   /* Returns the `struct tm' representation of *T,
  939.      offset OFFSET seconds east of UCT.  */
  940.   struct tm *
  941.   __offtime (const time_t *t, long int offset)
  942.   {
  943.     static struct tm tbuf;
  944.     register long int days, rem;
  945.     register int y;
  946.     register const unsigned short int *ip;
  947.  
  948.     if (t == NULL)
  949.       return NULL;
  950.  
  951.     days = *t / SECS_PER_DAY;
  952.     rem = *t % SECS_PER_DAY;
  953.     rem += offset;
  954.     while (rem < 0)
  955.     {
  956.       rem += SECS_PER_DAY;
  957.       --days;
  958.     }
  959.     while (rem >= SECS_PER_DAY)
  960.     {
  961.       rem -= SECS_PER_DAY;
  962.       ++days;
  963.     }
  964.     tbuf.tm_hour = rem / SECS_PER_HOUR;
  965.     rem %= SECS_PER_HOUR;
  966.     tbuf.tm_min = rem / 60;
  967.     tbuf.tm_sec = rem % 60;
  968.     /* January 1, 1970 was a Thursday.  */
  969.     tbuf.tm_wday = (4 + days) % 7;
  970.     if (tbuf.tm_wday < 0)
  971.       tbuf.tm_wday += 7;
  972.     y = 1970;
  973.     while (days >= (rem = __isleap(y) ? 366 : 365))
  974.     {
  975.       ++y;
  976.       days -= rem;
  977.     }
  978.     while (days < 0)
  979.     {
  980.       --y;
  981.       days += __isleap(y) ? 366 : 365;
  982.     }
  983.     tbuf.tm_year = y - 1900;
  984.     tbuf.tm_yday = days;
  985.     ip = __mon_lengths[__isleap(y)];
  986.     for (y = 0; days >= ip[y]; ++y)
  987.       days -= ip[y];
  988.     tbuf.tm_mon = y;
  989.     tbuf.tm_mday = days + 1;
  990.     tbuf.tm_isdst = -1;
  991.  
  992.     return &tbuf;
  993.   }
  994.  
  995.  
  996.   /* Return the `struct tm' representation of *T in UTC.  */
  997.   struct tm *
  998.   gmtime (const time_t *t)
  999.   {
  1000.     return __offtime(t, 0L);
  1001.   }
  1002.  #endif /* ifndef _HAVE_GMTIME */
  1003.  
  1004.  #ifndef _HAVE_MKTIME
  1005.  
  1006.   /* Return the `time_t' representation of TP and normalizes TP.
  1007.      Return (time_t) -1 if TP is not representable as a `time_t'.
  1008.      Note that 31 Dec 1969 23:59:59 is not representable
  1009.      because it is represented as (time_t) -1.  */
  1010.   time_t mktime (register struct tm *tp)
  1011.   {
  1012.     static struct tm min, max;
  1013.     static char init = 0;
  1014.  
  1015.     register time_t result;
  1016.     register time_t t;
  1017.     register int i;
  1018.     register const unsigned short *l;
  1019.     register struct tm *new;
  1020.     time_t end;
  1021.  
  1022.     if (tp == NULL)
  1023.     {
  1024.       errno = EINVAL;
  1025.       invalid();
  1026.     }
  1027.  
  1028.     if (!init)
  1029.     {
  1030.       init = 1;
  1031.       end = (time_t) LONG_MIN;
  1032.       new = gmtime(&end);
  1033.       if (new != NULL)
  1034.         min = *new;
  1035.       else
  1036.         min.tm_sec = min.tm_min = min.tm_hour =
  1037.       min.tm_mday = min.tm_mon = min.tm_year = INT_MIN;
  1038.  
  1039.       end = (time_t) LONG_MAX;
  1040.       new = gmtime(&end);
  1041.       if (new != NULL)
  1042.         max = *new;
  1043.       else
  1044.         max.tm_sec = max.tm_min = max.tm_hour =
  1045.       max.tm_mday = max.tm_mon = max.tm_year = INT_MAX;
  1046.     }
  1047.  
  1048.     /* Make all the elements of TP that we pay attention to
  1049.        be within the ranges of reasonable values for those things.  */
  1050.     #define  normalize(elt, min, max, nextelt)\
  1051.     while (tp->elt < min)                     \
  1052.     {                                         \
  1053.       --tp->nextelt;                          \
  1054.       tp->elt += max + 1;                     \
  1055.     }                                         \
  1056.     while (tp->elt > max)                     \
  1057.     {                                         \
  1058.       ++tp->nextelt;                          \
  1059.       tp->elt -= max + 1;                     \
  1060.     }
  1061.  
  1062.     normalize (tm_sec, 0, 59, tm_min);
  1063.     normalize (tm_min, 0, 59, tm_hour);
  1064.     normalize (tm_hour, 0, 24, tm_mday);
  1065.  
  1066.     /* Normalize the month first so we can use
  1067.        it to figure the range for the day.  */
  1068.     normalize (tm_mon, 0, 11, tm_year);
  1069.     normalize (tm_mday, 1, __mon_lengths[__isleap (tp->tm_year)][tp->tm_mon],
  1070.       tm_mon);
  1071.  
  1072.     /* Normalize the month again, since normalizing
  1073.        the day may have pushed it out of range.  */
  1074.     normalize (tm_mon, 0, 11, tm_year);
  1075.  
  1076.     /* Normalize the day again, because normalizing
  1077.        the month may have changed the range.  */
  1078.     normalize (tm_mday, 1, __mon_lengths[__isleap (tp->tm_year)][tp->tm_mon],
  1079.       tm_mon);
  1080.  
  1081.    /* Check for out-of-range values.  */
  1082.    #define  lowhigh(field, minmax, cmp)  (tp->field cmp minmax.field)
  1083.    #define  low(field)                   lowhigh(field, min, <)
  1084.    #define  high(field)                  lowhigh(field, max, >)
  1085.    #define  oor(field)                   (low(field) || high(field))
  1086.    #define  lowbound(field)              (tp->field == min.field)
  1087.    #define  highbound(field)             (tp->field == max.field)
  1088.    if (oor(tm_year))
  1089.      invalid();
  1090.    else
  1091.      if (lowbound(tm_year))
  1092.      {
  1093.        if (low(tm_mon))
  1094.          invalid();
  1095.        else
  1096.          if (lowbound(tm_mon))
  1097.          {
  1098.            if (low(tm_mday))
  1099.              invalid();
  1100.            else
  1101.              if (lowbound(tm_mday))
  1102.              {
  1103.                if (low(tm_hour))
  1104.                  invalid();
  1105.                else
  1106.                  if (lowbound(tm_hour))
  1107.                  {
  1108.                    if (low(tm_min))
  1109.                      invalid();
  1110.                    else
  1111.                      if (lowbound(tm_min))
  1112.                      {
  1113.                        if (low(tm_sec))
  1114.                        invalid();
  1115.                      }
  1116.                  }
  1117.              }
  1118.          }
  1119.      }
  1120.      else
  1121.        if (highbound(tm_year))
  1122.        {
  1123.          if (high(tm_mon))
  1124.            invalid();
  1125.          else
  1126.            if (highbound(tm_mon))
  1127.            {
  1128.              if (high(tm_mday))
  1129.                invalid();
  1130.              else
  1131.                if (highbound(tm_mday))
  1132.                {
  1133.                  if (high(tm_hour))
  1134.                    invalid();
  1135.                  else
  1136.                    if (highbound(tm_hour))
  1137.                    {
  1138.                      if (high(tm_min))
  1139.                        invalid();
  1140.                      else
  1141.                        if (highbound(tm_min))
  1142.                        {
  1143.                          if (high(tm_sec))
  1144.                          invalid();
  1145.                        }
  1146.                    }
  1147.                }
  1148.            }
  1149.        }
  1150.     t = 0;
  1151.     for (i = 1970; i > 1900 + tp->tm_year; --i)
  1152.       t -= __isleap(i) ? 366 : 365;
  1153.     for (i = 1970; i < 1900 + tp->tm_year; ++i)
  1154.       t += __isleap(i) ? 366 : 365;
  1155.     l = __mon_lengths[__isleap(1900 + tp->tm_year)];
  1156.     for (i = 0; i < tp->tm_mon; ++i)
  1157.       t += l[i];
  1158.     t += tp->tm_mday - 1;
  1159.     result = ((t * 60 * 60 * 24) +
  1160.              (tp->tm_hour * 60 * 60) +
  1161.              (tp->tm_min * 60) +
  1162.               tp->tm_sec);
  1163.  
  1164.     end = result;
  1165.    #if 0
  1166.     if (tp->tm_isdst < 0)
  1167.       new = localtime(&end);
  1168.     else
  1169.    #endif
  1170.       new = gmtime(&end);
  1171.     if (new == NULL)
  1172.       invalid();
  1173.     new->tm_isdst = tp->tm_isdst;
  1174.     *tp = *new;
  1175.  
  1176.     return result;
  1177.   }
  1178.  #endif /* ifndef _HAVE_MKTIME */
  1179.  
  1180.  #ifndef _FTIMEDEFINED
  1181.   /*
  1182.    * these functions have to convert a MS/DOS time to a UNIX time
  1183.    * and vice versa.
  1184.    * here comes the MS/DOS time structure
  1185.    */
  1186.   #ifdef _AMIGA_
  1187.    struct ftime
  1188.      {
  1189.        unsigned  int ft_year  : 7; /* Year minus 1980 */
  1190.        unsigned  int ft_month : 4;   /* 1..12 */
  1191.        unsigned  int ft_day   : 5;   /* 1..31 */
  1192.        unsigned  int ft_hour  : 5;   /* 0..23 */
  1193.        unsigned  int ft_min   : 6;   /* 0..59 */
  1194.        unsigned  int ft_tsec  : 5;   /* 0..59 /2 (!) */
  1195.      };
  1196.   #else
  1197.    struct ftime
  1198.    {
  1199.      unsigned  ft_tsec  : 5;   /* 0..59 /2 (!) */
  1200.      unsigned  ft_min   : 6;   /* 0..59 */
  1201.      unsigned  ft_hour  : 5;   /* 0..23 */
  1202.      unsigned  ft_day   : 5;   /* 1..31 */
  1203.      unsigned  ft_month : 4;   /* 1..12 */
  1204.      unsigned  ft_year  : 7; /* Year minus 1980 */
  1205.    };
  1206.   #endif
  1207.  #endif /* _FTIMEDEFINED */
  1208.  
  1209.  /*
  1210.   * Get file's timestamp and package it into a 32-bit word (MS_DOS-format).
  1211.   * This function should work on any system (even on AMIGAs) :-)
  1212.   */
  1213.  ulong get_filetime (char *filename)
  1214.  {
  1215.    struct ftime fti;
  1216.    ulong *retval = (ulong *) &fti;
  1217.    struct tm *utm;
  1218.    struct stat fst;
  1219.  
  1220.    *retval = 0UL;
  1221.  
  1222.    /* get file status */
  1223.    if (stat (filename, &fst) == 0)
  1224.    {
  1225.       /* get time of last modification and convert it to MS/DOS time */
  1226.      utm = gmtime (&fst.st_mtime);
  1227.  
  1228.      if (utm)
  1229.      {
  1230.        fti.ft_tsec  = utm->tm_sec / 2;
  1231.        fti.ft_min   = utm->tm_min;
  1232.        #ifdef _AMIGA_
  1233.         fti.ft_hour  = utm->tm_hour -6;/* US_TIME_COR */
  1234.        #else
  1235.         fti.ft_hour  = utm->tm_hour;
  1236.        #endif
  1237.        fti.ft_day   = utm->tm_mday;
  1238.        fti.ft_month = utm->tm_mon + 1;
  1239.        fti.ft_year  = utm->tm_year - 80;
  1240.        return (*retval);
  1241.      }
  1242.    }
  1243.  
  1244.    /* error exit */
  1245.    printf ("\007\nCan't get file's timestamp!\n");
  1246.    return (*retval);
  1247.  }
  1248.  
  1249.  #ifdef _AMIGA_
  1250.   #define _SETFTIME_OK
  1251.   /*
  1252.    * Set file's timestamp
  1253.    * This function only works on AMIGA-systems
  1254.    */
  1255.   void set_filetime (char *filename, ulong ftimestamp)
  1256.   {
  1257.     time_t atime;
  1258.     struct ftime *fti;
  1259.     struct tm utm;
  1260.     struct DateStamp fdate;
  1261.     unsigned long zeit;
  1262.     long fday;
  1263.     long fmin;
  1264.     long fsec;
  1265.   
  1266.  
  1267.     /* convert MS/DOS ftimestamp to UNIX atime */
  1268.     fti = (struct ftime *) &ftimestamp;
  1269.     utm.tm_sec   = fti->ft_tsec * 2;
  1270.     utm.tm_min   = fti->ft_min;
  1271.     utm.tm_hour  = fti->ft_hour;
  1272.     utm.tm_mday  = fti->ft_day;
  1273.     utm.tm_mon   = fti->ft_month - 1;
  1274.     utm.tm_year  = fti->ft_year +80;
  1275.     utm.tm_wday  = utm.tm_yday  =  utm.tm_isdst = 0;
  1276.     atime = mktime (&utm);
  1277.     zeit = gmtime(&atime);
  1278.  
  1279.     fday = (atime / 86400);    /* 86400sec per Day + systimecorr.*/
  1280.     fmin = (atime - (fday * 86400)) / 60;
  1281.     fsec = (atime - (fday * 86400) - (fmin * 60));
  1282.     
  1283.     fday = fday -2922;             /* correctur filetime>mktime */
  1284.     fsec = fsec * TICKS_PER_SECOND; /* correctur AMIGA-SYSTEM-TICKS */
  1285.     fdate.ds_Days = fday;
  1286.     fdate.ds_Minute = fmin;
  1287.     fdate.ds_Tick = fsec;
  1288.  
  1289.     SetFileDate(filename,&fdate);
  1290.  
  1291.     return(1);
  1292.   }
  1293.  #endif /* _AMIGA_ */
  1294.  
  1295.  #ifdef __unix__
  1296.   #define _SETFTIME_OK
  1297.   /*
  1298.    * Set file's timestamp
  1299.    * This function only works on UNIX-systems
  1300.    */
  1301.   void set_filetime (char *filename, ulong ftimestamp)
  1302.   {
  1303.     time_t atime;
  1304.     struct utimbuf utim;
  1305.     struct ftime *fti;
  1306.     struct tm utm;
  1307.  
  1308.     /* convert MS/DOS ftimestamp to UNIX atime */
  1309.     fti = (struct ftime *) &ftimestamp;
  1310.     utm.tm_sec   = fti->ft_tsec * 2;
  1311.     utm.tm_min   = fti->ft_min;
  1312.     utm.tm_hour  = fti->ft_hour;
  1313.     utm.tm_mday  = fti->ft_day;
  1314.     utm.tm_mon   = fti->ft_month - 1;
  1315.     utm.tm_year  = fti->ft_year + 80;
  1316.     utm.tm_wday  = utm.tm_yday  =  utm.tm_isdst = 0;
  1317.     atime = mktime (&utm);
  1318.  
  1319.     if (atime != -1)
  1320.     {
  1321.       /* set access time and modification time */
  1322.       utim.actime = atime;
  1323.       utim.modtime = atime;
  1324.       if (utime (filename, &utim) >= 0)
  1325.         return;
  1326.     }
  1327.  
  1328.     /* error exit */
  1329.     printf ("\007\nCan't set file's timestamp!");
  1330.     return;
  1331.   }
  1332.  #endif /* __unix__ */
  1333.  
  1334.  #ifndef _SETFTIME_OK
  1335.   /*
  1336.    * Set file's timestamp
  1337.    *
  1338.    */
  1339.   void set_filetime (char *filename, ulong ftimestamp)
  1340.   {
  1341.     /* error exit */
  1342.     printf ("\007\nset_filetime not (yet) implemented on this system!\n");
  1343.     printf ("7PLUS should NOT be circulated until it is implemented!!\n");
  1344.     printf ("Axel, DG1BBQ.\n");
  1345.     return;
  1346.   }
  1347.  #endif
  1348. #endif /* not __MSDOS__ or __TOS__ */
  1349.  
  1350.  
  1351. /*
  1352. *** get_hex: some compilers have real big trouble when reading hex values from
  1353. ***          a file with fscanf() that have leading zeros! e.g. 00A will be
  1354. ***          read as two separate values (0 and A)! grr!!
  1355. ***          get_hex skips all leading zeros to eliminate the problem.
  1356. ***
  1357.  */
  1358.  
  1359. uint get_hex (char *hex)
  1360. {
  1361.   register i = 0;
  1362.   uint   ret = 0;
  1363.  
  1364.   while (hex[i] == '0')
  1365.     i++;
  1366.   sscanf(hex+i, "%x", &ret);
  1367.   return (ret);
  1368. }
  1369.  
  1370.  
  1371. #ifdef _FNSPLIT
  1372. /*
  1373. ***       filenamesplit
  1374. ***       (by DL1MEN, taken from SP-ST, modified for portability)
  1375. ***
  1376. ***       split filename up into drive, path, name and extension.
  1377. ***
  1378.  */
  1379.  
  1380. void fnsplit(char *pth, char *dr, char *pa, char *fn, char *ft)
  1381. {
  1382.   char drv[MAXDRIVE], pat[MAXDIR], fna[MAXFILE], fty[MAXEXT], tmp[MAXPATH];
  1383.   char *p;
  1384.  
  1385.   strcpy(tmp,pth);
  1386.  
  1387.   if ((p = strchr(tmp,':')) != NULL)
  1388.   {
  1389.     *p++ = EOS;
  1390.     strcpy(drv,tmp);
  1391.   }
  1392.   else
  1393.   {
  1394.     p = tmp;
  1395.     drv[0] = EOS;
  1396.   }
  1397.   if ((pth = strrchr(p, PATHCHAR)) != NULL)
  1398.   {
  1399.     *pth++ = EOS;
  1400.     strcpy(pat,p);
  1401.   }
  1402.   else
  1403.   {
  1404.     pth = p;
  1405.     pat[0] = EOS;
  1406.   }
  1407.   if ((p = strchr(pth,'.')) != NULL)
  1408.   {
  1409.     strcpy(fty,p);
  1410.     fty[MAXEXT-1] = EOS;
  1411.     *p = EOS;
  1412.   }
  1413.   else
  1414.     fty[0] = EOS;
  1415.  
  1416.   strcpy(fna,pth);
  1417.   fna[MAXFILE-1] = EOS;
  1418.  
  1419.   if (dr)
  1420.   {
  1421.     strcpy(dr,drv);
  1422.     if (drv[0])
  1423.       strcat(dr,":");
  1424.   }
  1425.   if (pa)
  1426.   {
  1427.     strcpy(pa,pat);
  1428.     if (pat[0])
  1429.       strcat(pa, PATHSEP);
  1430.   }
  1431.   if (fn)
  1432.     strcpy(fn,fna);
  1433.   if (ft)
  1434.    strcpy(ft,fty);
  1435. }
  1436. #endif /** _FNSPLIT **/
  1437.  
  1438. #ifdef _ICMP
  1439. /* The following functions are unfortunately not avialable on all compilers */
  1440.  
  1441. /*
  1442. *** strupr - convert string to upper case.
  1443. ***
  1444. ***
  1445.  */
  1446.  
  1447. char *strupr (char *string)
  1448. {
  1449.   char *strcnvt (char *string, int flag);
  1450.  
  1451.   return (strcnvt (string, 1));
  1452. }
  1453.  
  1454. /*
  1455. *** strlwr - convert string to lower case.
  1456. ***
  1457. ***
  1458.  */
  1459.  
  1460. char *strlwr (char *string)
  1461. {
  1462.   char *strcnvt (char *string, int flag);
  1463.  
  1464.   return (strcnvt (string, 0));
  1465. }
  1466.  
  1467. /*
  1468. *** strcnvt - convert string to upper (flag == 1) or lower (flag == 0) case.
  1469. ***
  1470. ***
  1471.  */
  1472.  
  1473. char *strcnvt (char *string, int flag)
  1474. {
  1475.   register i = 0;
  1476.  
  1477.   while (string[i])
  1478.   {  
  1479.     string[i] = (flag)?toupper (string[i]):tolower (string[i]);
  1480.     i++;
  1481.   }
  1482.  
  1483.   return (string);
  1484. }
  1485.  
  1486. /*
  1487. *** stricmp - same as strcmp(), but ignores case.
  1488. *** s1 and s2 are not modified.
  1489. ***
  1490.  */
  1491.  
  1492. int stricmp (const char *s1, const char *s2)
  1493. {
  1494.   return (strnicmp (s1, s2, (size_t) 80));
  1495. }
  1496.  
  1497. /*
  1498. *** strnicmp - same as strncmp(), but ignores case.
  1499. *** s1 and s2 are not modified.
  1500. ***
  1501.  */
  1502.  
  1503. int strnicmp (const char *s1, const char *s2, size_t n)
  1504. {
  1505.   char _s1[81], _s2[81];
  1506.  
  1507.   strncpy (_s1, s1, 80);
  1508.   strncpy (_s2, s2, 80);
  1509.   strupr (_s1);
  1510.   strupr (_s2);
  1511.  
  1512.   return (strncmp (_s1, _s2, n));
  1513. }
  1514. #endif /** _ICMP **/
  1515.